/***************************************************************************
 *  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
 *  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
 *                                                                         *
 *  Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael          *
 *  Chastain, Michael Quan, and Mitchell Tse.                              *
 *                                                                         *
 *  In order to use any part of this Merc Diku Mud, you must comply with   *
 *  both the original Diku license in 'license.doc' as well the Merc       *
 *  license in 'license.txt'.  In particular, you may not remove either of *
 *  these copyright notices.                                               *
 *                                                                         *
 *  Much time and thought has gone into this software and you are          *
 *  benefitting.  We hope that you share your changes too.  What goes      *
 *  around, comes around.                                                  *
 ***************************************************************************/

/***************************************************************************
*	ROM 2.4 is copyright 1993-1998 Russ Taylor			   *
*	ROM has been brought to you by the ROM consortium		   *
*	    Russ Taylor (rtaylor@hypercube.org)				   *
*	    Gabrielle Taylor (gtaylor@hypercube.org)			   *
*	    Brian Moore (zump@rom.org)					   *
*	By using this code, you have agreed to follow the terms of the	   *
*	ROM license, in the file Rom24/doc/rom.license			   *
***************************************************************************/

/**************************************************************************
* STARTERMUD BY Chris Bunting. I know one may not consider this a huge
* advancement in Rom but it's not supposed to be. It's to make this a
* little easier for new Mud admins and intends to add the most requested
* features for new muds to build off of. Compiles with Cygwin & MSVC
*
* By using this code, You agree to leave this header in tack and that you
* do not release versions of this code which you call your own. If you 
* release a mud based on this, Credit must be given to me in the helps
* somewhere. I don't ask for much credit. Please don't deprive me of the
* little bit of work that I have done. Chris Bunting - chris@ddmg.net
**************************************************************************/

#if defined(macintosh)
#include <types.h>
#elif defined(WIN32)
#include <sys/types.h>
#include <time.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include "merc.h"
#include "music.h"
#include "recycle.h"

int channel_songs[MAX_GLOBAL + 1];
struct song_data song_table[MAX_SONGS];

void song_update(void)
{
    OBJ_DATA *obj;
    CHAR_DATA *victim;
    ROOM_INDEX_DATA *room;
    DESCRIPTOR_DATA *d;
    char buf[MAX_STRING_LENGTH];
    char *line;
    int i;

    /* do the global song, if any */
    if (channel_songs[1] >= MAX_SONGS)
	channel_songs[1] = -1;

    if (channel_songs[1] > -1)
    {
        if (channel_songs[0] >= MAX_LINES
        ||  channel_songs[0] >= song_table[channel_songs[1]].lines)
        {
	    channel_songs[0] = -1;

            /* advance songs */
	    for (i = 1; i < MAX_GLOBAL; i++)
	    	channel_songs[i] = channel_songs[i+1];
	    channel_songs[MAX_GLOBAL] = -1;
	}
	else
	{
	    if (channel_songs[0] < 0)
	    {
	    	sprintf(buf,"Music: %s, %s",
		    song_table[channel_songs[1]].group,
		    song_table[channel_songs[1]].name);
	    	channel_songs[0] = 0;
	    }
	    else
	    {
		sprintf(buf,"Music: '%s'",
		    song_table[channel_songs[1]].lyrics[channel_songs[0]]);
		channel_songs[0]++;
	    }

	    for (d = descriptor_list; d != NULL; d = d->next)
	    {
		victim = d->original ? d->original : d->character;

        	if ( d->connected == CON_PLAYING &&
             	     !IS_SET(victim->comm,COMM_NOMUSIC) &&
             	     !IS_SET(victim->comm,COMM_QUIET) )
            	     act_new("$t",d->character,buf,NULL,TO_CHAR,POS_SLEEPING);
            }
	}
    }

    for (obj = object_list; obj != NULL; obj = obj->next)
    {
	if (obj->item_type != ITEM_JUKEBOX || obj->value[1] < 0)
	    continue;

 	if (obj->value[1] >= MAX_SONGS)
	{
	    obj->value[1] = -1;
	    continue;
	}

	/* find which room to play in */

	if ((room = obj->in_room) == NULL)
	{
	    if (obj->carried_by == NULL)
	    	continue;
	    else
	    	if ((room = obj->carried_by->in_room) == NULL)
		    continue;
	}

	if (obj->value[0] < 0)
	{
	    sprintf(buf,"$p starts playing %s, %s.",
		song_table[obj->value[1]].group,song_table[obj->value[1]].name);
	    if (room->people != NULL)
		act(buf,room->people,obj,NULL,TO_ALL);
	    obj->value[0] = 0;
	    continue;
	}
	else
	{
	    if (obj->value[0] >= MAX_LINES 
	    || obj->value[0] >= song_table[obj->value[1]].lines)
	    {

		obj->value[0] = -1;

		/* scroll songs forward */
		obj->value[1] = obj->value[2];
		obj->value[2] = obj->value[3];
		obj->value[3] = obj->value[4];
		obj->value[4] = -1;
		continue;
	    }

	    line = song_table[obj->value[1]].lyrics[obj->value[0]];
	    obj->value[0]++;
	}

	sprintf(buf,"$p bops: '%s'",line);
	if (room->people != NULL)
	    act(buf,room->people,obj,NULL,TO_ALL);
    }
}

	    

void load_songs(void)
{
    FILE *fp;
    int count = 0, lines, i;
    char letter;

    /* reset global */
    for (i = 0; i <= MAX_GLOBAL; i++)
	channel_songs[i] = -1;

    if ((fp = fopen(MUSIC_FILE,"r")) == NULL)
    {
	bug("Couldn't open music file, no songs available.",0);
	fclose(fp);
	return;
    }

    for (count = 0; count < MAX_SONGS; count++)
    {
        letter = fread_letter(fp);
        if (letter == '#')
        {
            if (count < MAX_SONGS)
                song_table[count].name = NULL;
            fclose(fp);
            return;
        }
  	else
	    ungetc(letter,fp);

	song_table[count].group = fread_string(fp);
	song_table[count].name 	= fread_string(fp);

	/* read lyrics */
	lines = 0;

	for ( ; ;)
	{
	    letter = fread_letter(fp);

	    if (letter == '~')
	    {
		song_table[count].lines = lines;
		break;
	    }
	    else
		ungetc(letter,fp);
		
	    if (lines >= MAX_LINES)
   	    {
		bug("Too many lines in a song -- limit is  %d.",MAX_LINES);
		break;
	    }

	    song_table[count].lyrics[lines] = fread_string_eol(fp);
	    lines++;
	}
    }
}

void do_play(CHAR_DATA *ch, char *argument)
{
    OBJ_DATA *juke;
    char *str,arg[MAX_INPUT_LENGTH];
    int song,i;
    bool global = FALSE;

    str = one_argument(argument,arg);

    for (juke = ch->in_room->contents; juke != NULL; juke = juke->next_content)
	if (juke->item_type == ITEM_JUKEBOX && can_see_obj(ch,juke))
	    break;

    if (argument[0] == '\0')
    {
	send_to_char("Play what?\n\r",ch);
	return;
    }

    if (juke == NULL)
    {
	send_to_char("You see nothing to play.\n\r",ch);
	return;
    }

    if (!str_cmp(arg,"list"))
    {
	BUFFER *buffer;
  	char buf[MAX_STRING_LENGTH];
	int col = 0;
	bool artist = FALSE, match = FALSE;

	buffer = new_buf();
	argument = str;
	argument = one_argument(argument,arg);

	if (!str_cmp(arg,"artist"))
	    artist = TRUE;

	if (argument[0] != '\0')
	    match = TRUE;

	sprintf(buf,"%s has the following songs available:\n\r",
	    juke->short_descr);
	add_buf(buffer,capitalize(buf));

	for (i = 0; i < MAX_SONGS; i++)
	{
	    if (song_table[i].name == NULL)
		break;

	    if (artist && (!match 
	    || 		   !str_prefix(argument,song_table[i].group)))
		sprintf(buf,"%-39s %-39s\n\r",
		    song_table[i].group,song_table[i].name);
	    else if (!artist && (!match 
	    || 	 		 !str_prefix(argument,song_table[i].name)))
	    	sprintf(buf,"%-35s ",song_table[i].name);
	    else
		continue;
	    add_buf(buffer,buf);
	    if (!artist && ++col % 2 == 0)
		add_buf(buffer,"\n\r");
        }
        if (!artist && col % 2 != 0)
	    add_buf(buffer,"\n\r");

	page_to_char(buf_string(buffer),ch);
	free_buf(buffer);
	return;
    }

    if (!str_cmp(arg,"loud"))
    {
        argument = str;
        global = TRUE;
    }

    if (argument[0] == '\0')
    {
        send_to_char("Play what?\n\r",ch);
        return;
    }

    if ((global && channel_songs[MAX_GLOBAL] > -1) 
    ||  (!global && juke->value[4] > -1))
    {
        send_to_char("The jukebox is full up right now.\n\r",ch);
        return;
    }

    for (song = 0; song < MAX_SONGS; song++)
    {
	if (song_table[song].name == NULL)
	{
	    send_to_char("That song isn't available.\n\r",ch);
	    return;
	}
	if (!str_prefix(argument,song_table[song].name))
	    break;
    }

    if (song >= MAX_SONGS)
    {
	send_to_char("That song isn't available.\n\r",ch);
	return;
    }

    send_to_char("Coming right up.\n\r",ch);

    if (global)
    {
	for (i = 1; i <= MAX_GLOBAL; i++)
	    if (channel_songs[i] < 0)
	    {
		if (i == 1)
		    channel_songs[0] = -1;
		channel_songs[i] = song;
		return;
	    }
    }
    else 
    {
	for (i = 1; i < 5; i++)
	    if (juke->value[i] < 0)
	    {
		if (i == 1)
		    juke->value[0] = -1;
		juke->value[i] = song;
		return;
	     }
    }
}
